<?php
/*
 * * * * * * * * * * LICENCIA * * * * * * * * * * * * * * * * * * * * *

Copyright(C) 2014
 Universtiario de Tecnología Dr. Federico Rivero Palacio

Este programa es Software Libre y usted puede redistribuirlo y/o modificarlo
bajo los términos de la versión 3.0 de la Licencia Pública General (GPLv3)
publicada por la Free Software Foundation (FSF), es distribuido sin ninguna
garantía. Usted debe haber recibido una copia de la GPLv3 junto con este
programa, sino, puede encontrarlo en la página web de la FSF, 
específicamente en la dirección http://www.gnu.org/licenses/gpl-3.0.html

 * * * * * * * * * * ARCHIVO * * * * * * * * * * * * * * * * * * * * *

Nombre: manejoErrores.php
Diseñador: Jhonny Vielma
Programador: Jhonny Vielma
Fecha: 25/6/2014
Descripción:  
	   Clase manejoErrores esta clase permite tener un manejo detallado de los errores
	   del sitema al momento de la ejecucion de este mismo. Permite capturar lo errores
	   y exceptiones que lanza el sistema y manejar dichos errores y exceptiones  de una
	   manera ordena.Esta clase permitira que el sistema sea mantenible en el tiempo, ya
	   que dependiendo el tipo de vista que se este trabajando en el sistema, este mandara
	   el error en la vistas correspondient y guardando en un archivo la cantidad de errores
	   del sistema. 
	

 * * * * * * * * Cambios/Mejoras/Correcciones/Revisiones * * * * * * * *
Diseñador - Programador /   Fecha   / Descripción del cambio
 

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/


	class manejoErrores{
	
		/*  Funcion estatica que permite lanzar los errores capturados como exceptiones,
			esta funcion captura los errores del sistema y los lanza como una exception.
			Parametros de entrada:
				$tipo= Tipos de error valor integer.
				$mensaje= Mensaje de el error.
				$archivo= Archivo en el cual ocurrio el error.
				$linea= Linea donde ocurrio el error.
			Valores de salida:
				No posee.
			Exceptiones que lanza:
				Exception.
			Ejemplo de como usar:
				set_error_handler("manejoErrores::manejarErrores");
		*/

		public static function manejarErrores($tipo,$mensaje,$archivo,$linea){
			
			throw new Exception ($mensaje);
		}
		
		/*  Funcion estatica que permite lanzar las exceptiones no capturados
			en el sistema y procesarlas en el manejo de errores del sistema, esta 
			funcion permite que no se escapen exceptiones.
			Parametros de entrada:
				$e= Exception no captura.
			Valores de salida:
				No posee.
			Exceptiones que lanza:
				Ninguna
			Ejemplo de como usar:
				set_exception_handler("manejoErrores::manejadorExcepcionesNoCapturadas");
		*/
		public static function manejadorExcepcionesNoCapturadas($e){
			self::manejarExcepcion($e);
		}
		
		/*  Funcion estatica que permite obtener el codigo de error del archivo numeroErrores.txt
			ya que este posee el numero de errores y exceptiones que ha disparado el sistema y asi
			mantener un menejo de error ordenado.
			Parametros de entrada:
				No posee.
			Valores de salida:
				Cantidad de errores:integer.
			Exceptiones que lanza:
				Ninguna
			Ejemplo de como usar:
				Dentro de la misma clase: self::obtenerCodigoError();
				Fuera de la clase: manejoErrores::obtenerCodigoError();
		*/

		public static function obtenerCodigoError(){
			$archivo=fopen("numeroErrores.txt","r");
			 return fgets($archivo);
			
		}
		/*  Funcion estatica que permite crear los archivos en el sistema en el cual se manejaran los 
			errores. Son  2 archivos errores.txt donde se encuentra la especificacion del error en 
			especifico y numeroErrores.txt que posee la cantidad de errores que ha lanzado el sistema.
			Parametros de entrada:
				No posee.
			Valores de salida:
				No posee;
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::crearArchivos();
				Fuera de la clase: manejoErrores::crearArchivos();
		*/
		public static function crearArchivos(){
			$archivo=fopen("errores.txt","w+");
			fclose($archivo);
			$archivo=fopen("numeroErrores.txt","w+");
			fputs($archivo,"0");
			fclose($archivo);
		}
		/*  Funcion estatica que permite verificar si algun archivo ya esta creado un algun directorio
			especifico del sistema.
			Parametros de entrada:
				$nombre= Ruta del archivo a verificar.
			Valores de salida:
				true= En caso de existir.
				false= En caso de no existir.
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::existeArchivo();
				Fuera de la clase: manejoErrores::existeArchivo();
		*/
		public static function existeArchivo($nombre){
			return file_exists ($nombre);
		}
		/*  Funcion estatica que permite escribir el codigo de error pasado por parametro en el
			archivo que tambien se pasa por parametro
			Parametros de entrada:
				$nombre= Ruta del archivo a verificar.
			Valores de salida:
				No posee.
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirCodigoError("errores.txt",1);
				Fuera de la clase: manejoErrores::escribirCodigoError("errores.txt",1);
		*/   
		public static function escribirCodigoError($nombre,$codigo){
			$archivo=fopen($nombre,"w+");
			fputs($archivo,$codigo);
			fclose($archivo);
			
		}
		/*  Funcion estatica que permite escribir en json la exception pasada por parametro, esto para
			tener el manejo de errores a la hora de hacer consultas ajax al servidor, esto agilizara muchos
			procesos y tiempo que se empleaba antes para ver los errores ajax.
			Parametros de entrada:
				$e= Exception a escribir.
			Valores de salida:
				No posee.
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirExceptionJson(Exception $e);
				Fuera de la clase: manejoErrores::escribirExceptionJson(Exception $e);
		*/  
		public static function escribirExceptionJson(Exception $e){
			$estatus =-1;
			$codigo= manejoErrores::obtenerCodigoAEscribir();
			$cad = ""
		     . "{"
			 . "\"estatus\":\"" . $estatus. "\","
			 . "\"codigo\":\"" . $codigo. "\","
			 . "\"mensaje\":\"" . $e->getMessage(). "\""
			 . "}"
			 . "";
			echo $cad;
			
		}
		/*  Funcion que permite obtener el codigo de error que se acaba de generar, siempre sera un 
			numero mas a el anterior error originado es decir, si el anterior fue 8 lo que retornara
			la funcion sera un 9.Esto permitira tener un manejo ordenado de errores en el sistema.
			Parametros de entrada:
				No posee.
			Valores de salida:
				codigo de error generado: integer.
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::obtenerCodigoAEscribir();
				Fuera de la clase: manejoErrores::obtenerCodigoAEscribir();
		*/  
		public static function obtenerCodigoAEscribir(){
				return self::obtenerCodigoError() + 1;
		}
		/*  Funcion que permite tener el manejo detallado de la exception ya que dependiendo de la vista
			en la que se genero el error esta funcion permite tener el manejo a la hora de mostrar la informacion
			en el mismo tipo de vista en el que este trabajando el desarrolar.
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				No posee
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::manejarExcepcion($e);
				Fuera de la clase: manejoErrores::manejarExcepcion($e);
		*/  
		public static function manejarExcepcion($e){
			if ((self::existeArchivo("numeroErrores.txt")!=true) || (self::existeArchivo("errores.txt")!=true))
				self::crearArchivos();
			
			$formato= $_POST["m_formato"];
			
			self::escribirExceptionArchivo($e);
			
			if($formato=="json")
				self::escribirExceptionJson($e);
			else if ($formato=="html5"){
				self::escribirExceptionHtml5($e);
			} else if ($formato=="pdf"){
				self::escribirExceptionPdf($e);
			} else if ($formato=="odt"){
				self::escribirExceptionOdt($e);
			} else if ($formato=="txt"){
				self::escribirExceptionTxt($e);
				
			}else 
				echo "Formato invalida en manejoErrores::manejarException ".$vista;
			manejoErrores::escribirCodigoError("numeroErrores.txt", manejoErrores::obtenerCodigoAEscribir());
		}
		/*  Funcion que permite escribir en el archivo errores.txt los errores producidos en el sistema
			en tiempo de ejecucion. Esta funcion guarda el error en el archivo con su codigo, mensaje, linea
			y traza de todo el error en general en un formato entendible y legible.
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				No posee
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirExceptionArchivo(Exception $e);
				Fuera de la clase: manejoErrores::escribirExceptionArchivo(Exception $e);
		*/  
		public static function escribirExceptionArchivo(Exception $e){
			$archivo=fopen("errores.txt","a");
			$codigoError=self::obtenerCodigoAEscribir();
			$cl = "\r\n";
			$tab = "\t";
			$cadena="";
			$cadena.=$cl."**************************** Error n° ".$codigoError." *****************************";
			$cadena.=$cl."codigo Error: $codigoError";
			$cadena.=$cl."Mensaje error: ".$e->getMessage()."";
			$cadena.=$cl."Archivo Error: ".$e->getFile()."";
			$cadena.=$cl."Linea Error: ".$e->getLine()."";
			$cadena.=$cl."Trayecto:";
			$cadena.=implode("\n\t\t",explode("\n",$cl.$e->gettraceAsString()));
			fputs($archivo,$cadena ); 
			fclose($archivo);
		}
		
		/*  Funcion que permite escribir en un archivo pdf los errores producidos en el sistema
			en tiempo de ejecucion..
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				No posee
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirExceptionPdf(Exception $e);
				Fuera de la clase: manejoErrores::escribirExceptionPdf(Exception $e);
		*/  
		public static function escribirExceptionPdf(Exception $e){
			$mensaje= $e->getMessage();
			$codigo= self::obtenerCodigoAEscribir();
			require_once("mensajePdf.php");
		}
		/*  Funcion que permite escribir en HTML5 los errores producidos en el sistema
			en tiempo de ejecucion..
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				No posee
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirExceptionHtml5(Exception $e);
				Fuera de la clase: manejoErrores::escribirExceptionHtml5(Exception $e);
		*/ 
		public static function escribirExceptionHtml5(Exception $e){
			$mensaje= $e->getMessage();
			$codigo= self::obtenerCodigoAEscribir();
			require_once("mensajeErrorHtml5.php");
		}
		/*  Funcion que permite escribir en TXT los errores producidos en el sistema
			en tiempo de ejecucion..
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				No posee
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirExceptionTxt(Exception $e);
				Fuera de la clase: manejoErrores::escribirExceptionTxt(Exception $e);
		*/ 
		public static function escribirExceptionTxt(Exception $e){
			$mensaje= $e->getMessage();
			$codigo= self::obtenerCodigoAEscribir();
			require_once("mensajeErrorTxt.php");
		}
		/*  Funcion que permite obtener los traces de una exception los de la pasada por 
			parametro, los traces son todo el recorrido que ha tenido e error o la exception.
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				Traces: array().
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::obtenerTraces(Exception $e);
				Fuera de la clase: manejoErrores::obtenerTraces(Exception $e);
		*/ 
		public static function obtenerTraces(Exception $e){
				return $traces=  $e->gettrace();
			
		} 
		/*  Funcion que permite armar una cadena de los traces de una exception los de la pasada por 
			parametro, los traces son todo el recorrido que ha tenido e error o la exception.
			Parametros de entrada:
				$e= Exception capturada.
			Valores de salida:
				Cadena De traces: String.
			Exceptiones que lanza:
				Ninguna.
			Ejemplo de como usar:
				Dentro de la misma clase: self::escribirTraces(array $traces);
				Fuera de la clase: manejoErrores::escribirTraces(array $traces);
		*/ 
		public static function escribirTraces(array $traces){
				$tab = "\t";
				$cl = "\r\n";
				$cad=$cl.$tab;
				echo"entro"; 
				for ($i=0; $i<count($traces);$i++){
					
					$cad.=$cl.$tab.$tab.$tab."Recorrido ".($i+1);
					$cad.=$cl.$tab.$tab.$tab.$tab."archivo: ".$traces[$i]['file'];
					$cad.=$cl.$tab.$tab.$tab.$tab."funcion: ".$traces[$i]['function'];
					
					
				}
			return $cad;
		}


	}


?>
